Mi a különbség a „git pull” és a „git fetch” között?

1
2
Következő
A legegyszerűbben kifejezve: a git pull egy git beolvasást követ, amelyet egy git egyesítés követ.
Bármikor elvégezhet egy git-lekérést a távkövető ágak frissítéséhez a refs / remotes /  / alatt.
Ez a művelet soha nem változtatja meg a saját helyi fiókjait a referenciák / fejek alatt, és biztonságosan elvégezhető a munkamásolat megváltoztatása nélkül. Még hallottam olyanokról, akik rendszeresen futtatják a git-lekérést a háttérben végzett munkában (bár ezt nem javasolnám).
A git húzás az, amit tenne, ha a helyi fiókot naprakészen látná a távoli verziójával, és frissítené a többi távkövető ágat is.
A git pull Git dokumentációjából:
Alapértelmezett módjában a git pull rövidítés a git lekéréshez, majd a git egyesítés FETCH_HEAD.
|
A pull használatakor Git megpróbálja automatikusan elvégezni a munkáját helyetted. Környezetérzékeny, ezért a Git beolvasztja az összes húzott elkötelezettséget abba az ágba, amelyben éppen dolgozik. A pull automatikusan összevonja az elkötelezettségeket anélkül, hogy lehetővé tenné azok áttekintését. Ha nem kezeli szorosan fiókjait, gyakran konfliktusokba ütközhet.
Amikor lekéred, a Git összegyűjti a célágból az összes olyan elkötelezettséget, amely nem létezik az aktuális fiókban, és tárolja azokat a helyi adattárban. Ez azonban nem egyesíti őket a jelenlegi fiókkal. Ez különösen akkor hasznos, ha naprakészen kell tárolnia az adattárat, de azon dolgozunk, amely meghibásodhat, ha frissíti a fájlokat.
Az összevonások integrálásához a fő ágba az egyesítést használja.
|
Fontos, hogy szembeállítsuk a git tervezési filozófiáját egy olyan hagyományosabb forrásellenőrző eszköz filozófiájával, mint az SVN.
A Subversion-t kliens / szerver modellel tervezték és építették. Egyetlen lerakat található, amely a kiszolgáló, és több kliens lekérheti a kódot a szerverről, dolgozhat rajta, majd visszaválaszthatja azt a szervernek. Az a feltételezés, hogy az ügyfél mindig kapcsolatba léphet a szerverrel, amikor műveletet kell végrehajtania.
A Git egy elosztottabb modell támogatására készült, és nincs szükség központi adattárra (bár mindenképpen használhat ilyet, ha úgy tetszik). A git szintén úgy lett megtervezve, hogy az ügyfélnek és a "szervernek" ne kelljen egyszerre online lennie. A Git-et úgy tervezték, hogy a megbízhatatlan linken lévő emberek akár e-mailben is kicserélhessék a kódot. Lehetőség van teljesen leválasztva dolgozni, és CD-t égetni a giten keresztül történő kódcserére.
Ennek a modellnek a támogatása érdekében a git fenntart egy helyi adattárat a kóddal, valamint egy további helyi adattárat, amely tükrözi a távoli adattár állapotát. A távoli adattár egy példányának helyben tartásával a git kitalálja a szükséges változtatásokat akkor is, ha a távoli adattár nem érhető el. Később, amikor el kell küldenie a módosításokat másnak, a git változások halmazaként továbbíthatja azokat a távoli adattár számára ismert időpontból.
A git fetch az a parancs, amely azt mondja: "frissítse a távoli adattár helyi másolatát."
A git pull azt mondja: "vigye a távoli adattár változásait oda, ahol a saját kódomat tárolom."
Általában a git pull ezt egy git-lekéréssel végzi, hogy a távoli adattár helyi másolatát naprakész állapotba hozza, majd egyesíti a változtatásokat saját kódtárába és esetleg munkamásolatába.
Az elvitelre azt kell szem előtt tartani, hogy a munkaállomáson gyakran van legalább egy projekt másolata. Az egyik példány a saját adattárad, a saját előzményeiddel. A második példány a munkamásolata, ahol szerkeszt és épít. A harmadik példány a távoli adattár helyi "gyorsítótárazott" példánya.
|
Itt van Oliver Steele képe arról, hogy mindez hogyan illeszkedik egymáshoz:
Ha van elegendő érdeklődés, feltételezhetem, hogy frissíthetem a képet, hogy hozzáadjam a git klónt és a git egyesítést ...
|
A git fetch egyik felhasználási esete az, hogy az alábbiakban közöljük a távoli ágban bekövetkezett változásokat az utolsó húzás óta ... így ellenőrizheti, mielőtt elvégezne egy tényleges húzást, amely megváltoztathatja az aktuális ág és a munkapéldány fájljait.
git letöltés
git diff ... eredet
Lásd: https://git-scm.com/docs/git-diff a diff parancs dupla- és hármaspontos szintaxisáról
|
Kicsit költségembe került, hogy megértsem, mi a különbség, de ez egy egyszerű magyarázat. A helyi mester mester fióktelep.
Ha klónoz egy adattárat, akkor a teljes tárhelyet lekéri a helyi gazdagépnek. Ez azt jelenti, hogy abban az időben van egy origó / master mutató a HEAD-re és a master ugyanarra a HEAD-re mutat.
amikor elkezd dolgozni, és elkötelezi magát, akkor a mester mutatót a HEAD + elkötelezettségek közé kell vinnie. De az origó / mester mutató még mindig arra mutat, hogy mi volt, amikor klónoztál.
Tehát a különbség a következő lesz:
Ha git-lekérést hajt végre, akkor csak a távoli adattár (GitHub) összes változását fogja lekérni, és az origó / master mutatót a HEAD-be helyezi. Eközben a helyi kirendeltség-mester folyamatosan arra mutat, ahol van.
Ha git húzást hajt végre, akkor az alapvetően be fogja tölteni (az előzőekben leírtaknak megfelelően), és egyesíti az új módosításokatelágazás és helyezze a mutatót a HEAD-be.
|
Néha a vizuális ábrázolás segít.
|
Röviden
A git fetch hasonló a pull-hoz, de nem egyesül. azaz távoli frissítéseket (referenciákat és objektumokat) kap, de a helyi változatlan marad (vagyis az origó / master frissül, de a master változatlan marad).
git pull lehúz egy távirányítóról és azonnal összeolvad.
Több
a git klón repót klónoz.
A git rebase ideiglenes területre menti az aktuális fiókjából azokat a dolgokat, amelyek nincsenek az upstream ágban. A fiókteleped most megegyezik a módosítások megkezdése előtt. Tehát a git pull -rebase lehúzza a távoli módosításokat, visszatekercseli a helyi fiókot, egyenként visszajátssza a változtatásokat a jelenlegi fiók tetején, amíg naprakész nem lesz.
Ezenkívül a git branch -a pontosan megmutatja, hogy mi történik az összes fiókjával - helyi és távoli.
Ez a blogbejegyzés hasznos volt:
A különbség a git pull, a git fetch és a git klón (és a git rebase) között - Mike Pearce
és kiterjed a git pull, a git fetch, a git klón és a git rebase.
====
FRISSÍTÉS
Gondoltam, hogy frissítem ezt, hogy megmutassam, hogyan is használja ezt a gyakorlatban.
Frissítse a helyi repót a távvezérlőről (de ne egyesítse):
git letöltés
A frissítések letöltése után nézzük meg a különbségeket:
git diff master eredet / master
Ha elégedett ezekkel a frissítésekkel, akkor egyesítse:
git húzás
Megjegyzések:
A 2. lépésről: A helyi és távirányítók közötti különbségekről lásd: Hogyan lehet összehasonlítani a helyi git ágat a távoli ágával?
A 3. lépésre: Valószínűleg pontosabb (pl. Gyorsan változó repo esetén) itt git rebase eredetet végrehajtani. Lásd @Justin Ohms megjegyzését egy másik válaszban.
Lásd még: http://longair.net/blog/2009/04/16/git-fetch-and-merge/
|
git-pull - Letöltés egy másik tárolóból vagy egy helyi fiókból és egyesítés azzal
SZINOPSZIS
git pull ...
LEÍRÁS
Futtatja a git-fetch-et a megadott paraméterekkel, és a git-merge hívást egyesíti a
beolvasott fej (ek) az aktuális ágba. A --rebase használatával git-rebase-t hív
git-merge helyett.
Ne feledje, hogy használhatja. (aktuális könyvtár), mint a 
a helyi adattárból - ez hasznos a helyi fiókok egyesítésénél
a jelenlegi ágba.
Vegye figyelembe azt is, hogy az opciók önmagában a git-pull és a mögöttes git-merge számára jelentettek
a git-fetch-re szánt opciók előtt kell megadni.
Meghúzza, ha össze szeretné vonni az előzményeket, és be kellene töltenie, ha csak 'a kódet akarja', mivel néhány ember címkézett néhány cikket errefelé.
|
Letölthet egy távoli adattárból, megnézheti a különbségeket, majd húzhatja vagy egyesítheti.
Ez egy példa az eredet nevű távoli adattárra és a master nevű ágra, amely a távoli ág eredetét / masterét követi:
git checkout master
git letöltés
git diff eredet / master
git rebase eredet mester
|
A rövid és egyszerű válasz az, hogy a git pull egyszerűen git fetch, majd git merge.
Nagyon fontos megjegyezni, hogy a git pull automatikusan egyesül, akár tetszik, akár nem. Ez természetesen összeolvadási konfliktusokat eredményezhet. Tegyük fel, hogy a távvezérlője eredetű, az ága pedig mester. Ha megkapja a diff eredetet / mestert a húzás előtt, akkor legyen némi elképzelése a lehetséges egyesülési konfliktusokról, és ennek megfelelően felkészítheti a helyi fiókot.
A húzáson és a lökésen kívül néhány munkafolyamat magában foglalja a git újrabázist is, például ezt, amelyet a linkelt cikkben átfogalmazok:
git pull eredet mester
git pénztár foo-ág
git rebase master
git push eredetű foo-ág
Ha ilyen helyzetbe kerül, akkor kísértésbe eshet, hogy felhúzza a --rebase-t. Hacsak nem igazán, tényleg tudja, mit csinál, én ezt javasolnám. Ez a figyelmeztetés a git-pull kézikönyv oldaláról származik, a 2.3.5-ös verzióhoz:
Ez potenciálisan veszélyes működési mód. Átírja
történelem, ami nem ígér semmit, amikor közzétette ezt a történelmet
már. Csak akkor használja ezt az opciót, ha elolvasta a git-rebase (1)
gondosan.
|
OK, itt van néhány információ a git pullról és a git fetch-ről, így megértheti a tényleges különbségeket ... néhány egyszerű szóval a fetch megkapja a legfrissebb adatokat, de a kód nem változik, és nem fog elrontani a jelenlegi helyi fiókkóddal , de húzza be a kódváltozásokat és egyesítse a helyi fiókot, olvassa el, hogy további részleteket kapjon mindegyikről:
git letöltés
Letölti az összes hivatkozást és objektumot, valamint minden új ágat a helyi adattárba ...
Húzza le az ágakat és / vagy a címkéket (együttesen: "ref") egy vagy több
más adattárak, a kitöltésükhöz szükséges tárgyakkal együtt
történetek. A távkövetési ágak frissülnek (lásd a leírást
a viselkedés ellenőrzésének módjairól).
Alapértelmezés szerint minden olyan címke, amely a beolvasott előzményekbe mutat
elhozták is; a hatás az, hogy olyan címkéket töltsön le, amelyek azokra az ágakra mutatnak
érdekli. Ez az alapértelmezett viselkedés a
a --tags vagy --no-tag opciókat, vagy konfigurálással
távoli..tagOpt. A címkéket kifejezetten lekérő refspec használatával
be tudja tölteni azokat a címkéket, amelyek nem az Ön érdekelt ágaiba mutatnak
be is.
a git fetch lehívhatvagy egyetlen megnevezett tárház vagy URL, vagy
több tárból egyszerre, ha megadják, és van egy
távirányítók. bejegyzés a konfigurációs fájlba. (Lásd: git-config1).
Ha nincs megadva távvezérlő, alapértelmezés szerint a távoli távoli lesz
használt, kivéve, ha egy upstream ág van konfigurálva az áramra
ág.
A beolvasott hivatkozások neve és az objektum neve
mutatnak, a .git / FETCH_HEAD címre vannak írva. Ez az információ lehet
szkriptek vagy más git parancsok, például git-pull.
git húzás
A távoli és az aktuális fiók közötti változásokat a helyi ...
Beépíti a távoli adattárból az aktuális ágba történő változásokat.
Alapértelmezett módjában a git pull rövidítés a git lekéréshez, amelyet követ
git egyesítés FETCH_HEAD.
Pontosabban, a git pull futtatja a git letöltést a megadott paraméterekkel és
A hívások git merge a beolvasott ágfejek áramba egyesítéséhez
ág. A --rebase használatával a git újraindítást futtatja a git egyesítés helyett.
a távoli adattár neve legyen
git-fetch1. megnevezhet egy tetszőleges távoli hivatkozást (például
a címke neve) vagy akár a megfelelő hivatkozások gyűjteménye
távkövető ágak (pl. refs / heads /: refs / remotes / origin /),
de általában a távoli adattárban található fiók neve.
A és alapértelmezett értékei a következőre olvashatók le:
A "távoli" és az "egyesítés" konfiguráció az aktuális ághoz, a
git-branch - track.
Az alábbi látványt is létrehozom, hogy megmutassam, hogyan működik együtt a git fetch és a git pull ...
|
Ez az interaktív grafikus ábrázolás nagyon hasznos a git megértésében: http://ndpsoftware.com/git-cheatsheet.html
A git fetch csak "letölti" a változásokat a távirányítóról a helyi adattárba. A git pull letölti a változásokat és beolvasztja őket az aktuális fiókjába. "Alapértelmezett módjában a git pull rövidítés a git lekéréshez, majd a git egyesítés FETCH_HEAD."
|
Bónusz:
A pull & fetch szóval a fenti válaszokban egy érdekes trükköt szeretnék megosztani,
git pull --rebase
Ez a fenti parancs a leghasznosabb parancs az életemben, amely sok időt takarított meg.
Mielőtt az új elkötelezettségeket kiszolgálóra tolná, próbálkozzon ezzel a paranccsal, és ez automatikusan szinkronizálja a legújabb szerver-változásokat (egy lekérés + egyesítéssel), és az elkötelezettséget a git napló tetején fogja elhelyezni. Nem kell aggódnia a kézi húzás / egyesítés miatt.
További részletek: http://gitolite.com/git-pull--rebase
|
Szeretem, ha vizuálisan ábrázolom a helyzetet, hogy megértsem ezeket a dolgokat. Lehet, hogy más fejlesztők is szeretnék látni, ezért íme a kiegészítésem. Nem vagyok teljesen biztos abban, hogy mindez helyes, ezért kérjük, tegyen megjegyzést, ha hibát talál.
HELYI RENDSZER
. ==================================================== ===
=================. ================= =================== =============
TÁVIRÁNYÍTÓ TÁROLÓ. TÁVOLI TÁROLÓ HELYI TÁROLÓ MUNKAMUNKÁJA
(EREDET)          . (Gyorsítótárazott)
például,      . tükör a
egy github repo. . távoli repo
Is lehet       .
több repo.
.
.
FETCH * ------------------> *
A távoli távoli gyorsítótár frissül az eredetével (vagy többszörösével)
külső források, vagyis a git elosztott jellege)
.
HÚZZ * ------------------------------------------------ --------> *
a módosításokat közvetlenül a helyi példányba olvasztják. amikor konfliktusok lépnek fel,
döntéseket kérnek tőled.
.
ELKÖVETNI            . * <--------------- *
Amikor például felforgatásból származik, azt gondolhatja, hogy elkötelezett
frissíteni fogja az eredetet. A git-ben csak a helyi repo-val történik elkötelezettség.
.
PUSH * <--------------------------------------- *
Szinkronizálja a változtatásokat az eredethez.
A távvezérlő lehúzott tükrének néhány fő előnye:
Teljesítmény (görgessen végig minden elkötelezettséget és üzenetet anélkül, hogy megpróbálná átpréselni a hálózaton)
Visszajelzés a helyi repo állapotáról (például az Atlassian's SourceTree-t használom, amely izzóval jelzi, hogy az eredethez képest előre vagy mögött vagyok-e. Ezeket az információkat egy GIT FETCH-mal lehet frissíteni).
|
Ezzel is küzdöttem. Valójában pontosan ugyanarról a kérdésről kerestem a Google keresését. Mindezen válaszok elolvasása végül képet festett a fejemben, és úgy döntöttem, hogy megpróbálom ezt lecsökkenteni, szemügyre véve a 2 tár és 1 homokozó állapotát és az idővel végrehajtott műveleteket, miközben nézem a verziójukat. Tehát itt álltam elő. Kérem, javítson ki, ha bárhol elrontottam.
A három repo egy lekéréssel:
--------------------- ----------------------- ------ -----------------
- Távoli repo - - Távoli repo - - Távoli repo -
- - - tolódik - - -
- @ R01 - - @ R02 - - @ R02 -
--------------------- ----------------------- ------ -----------------
--------------------- ----------------------------------------------
- Helyi repo - - Helyi repo - - Helyi repo -
- húzás - - - - lekérés -
- @ R01 - - @ R01 - - @ R02 -
--------------------- ----------------------- ------ -----------------
--------------------- ----------------------- ------ -----------------
- Helyi homokozó - - Helyi homokozó - - Helyi homokozó -
- Pénztár - - új munka elvégezve - - -
- @ R01 - - @ R01 + - - @ R01 + -
--------------------- ----------------------- ------ -----------------
A három repó húzással
--------------------- ----------------------- ------ -----------------
- Távoli repo - - Távoli repo - - Távoli repo -
- - - tolódik - - -
- @ R01 - - @ R02 - - @ R02 -
--------------------- ----------------------- ------ -----------------
--------------------- ----------------------- ------ -----------------
- Helyi repo - - Helyi repo - - Helyi repo -
- húzás - - - - húzás -
- @ R01 - - @ R01 - - @ R02 -
--------------------- ----------------------- ------ -----------------
--------------------- ----------------------- ------ -----------------
- Helyi homokozó - - Helyi homokozó - - Helyi homokozó -
- Pénztár - - új munka elvégezve - - egyesítve az R02-vel -
- @ R01 - - @ R01 + - - @ R02 + -
--------------------- ----------------------- ------ -----------------
Ez segített megérteni, hogy miért nagyon fontos a lekérés.
|
A GIT Fetch és a GIT Pull közötti különbség a következő forgatókönyvvel magyarázható:
(Szem előtt tartva, hogy a képek hangosabban beszélnek, mint a szavak!, Képi ábrázolást adtam)
Vegyünk egy példát arra, hogy egy projekten dolgozik a csapat tagjaival. Tehát a projektnek lesz egy fő ága, és az összes közreműködőnek el kell építenie a saját helyi adattárába, majd ezen a helyi ágon kell dolgoznia a modulok módosításán / hozzáadásán, majd a fő ághoz való visszalépéshez.
Így,
A két fiók kezdeti állapota, amikor a fő projektet a helyi adattárban elágazta, ilyen lesz ((A, B és C a projekt már befejezett modulok)
Most elkezdtél dolgozni az új modulon (tegyük fel, hogy D), és amikor befejezted a D modult, a fő ágra akarod tolni, de közben az történik, hogy egyik csapattársad kifejlesztett új E, F és módosított C.
Tehát most az történt, hogy a helyi adattár nem marad el a projekt eredeti előrehaladása mögött, és így a változtatások fő ágra való tolása konfliktusokhoz vezethet, és a D modul hibás működéséhez vezethet.
Az ilyen jellegű problémák elkerülése és a projekt eredeti előrehaladásával párhuzamosan történő munkavégzés kétféle módon lehetséges:
1. Git Fetch - Ez letölti az eredet / fő ág projektben végrehajtott összes olyan módosítást, amely nincs jelen a helyi fiókban. És megvárja, amíg a Git Merge parancs alkalmazza a lerakatra vagy az ágra behozott módosításokat.
Tehát most gondosan figyelemmel kísérheti a fájlokat, mielőtt egyesítené azokat a tárával. És módosíthatja a D-t is, ha szükséges a módosított C miatt.
2. Git Pull - Ez frissíti a helyi fiókot az origóval / fő ággal, vagyis valójában amit csinál, az a Git Fetch és a Git kombinációja egymás után.
De ez konfliktusokat okozhat, ezért ajánlott a Git Pull használatát tiszta másolattal.
|
Egyszerűen azt mondjuk:
git pull == git fetch + git egyesítés
Ha futtatja a git pull alkalmazást, akkor nem kell egyesítenie az adatokat a helyi fájlba. Ha futtatja a git fetch-et, az azt jelenti, hogy futtatnia kell a git merge-t, hogy a legfrissebb kódot elérje a helyi gépen. Ellenkező esetben a helyi gép kódja nem változik összeolvadás nélkül.
Tehát a Git Guiban, amikor lekér, össze kell egyesítenie az adatokat. Maga a Fetch nem változtatja meg a kódot a helyi nyelven. Ezt a kód frissítésével ellenőrizheti lekéréssel
ha egyszer elhozza és meglátja; a kód nem fog változni. Aztán egyesül ... Meglátja a megváltozott kódot.
|
A git fetch lehúzza a kódot a távoli szerverről a helyi adattár nyomkövetési ágaihoz. Ha a távvezérlő neve origó (alapértelmezett), akkor ezek az ágak az eredeten belül lesznek (például origin / master, origin / mybranch-123 stb.). Ezek nem az Ön jelenlegi ágai, hanem a szerverről érkező ágak helyi másolatai. .
A git pull elvégzi a git lekérését, de azután a nyomkövetési ág kódját is egyesíti az aktuálisbaaz ág helyi változata. Ha még nem áll készen a változásokra, először csak a git letöltést kell elvégeznie.
|
A git fetch lekéri a távoli ágakat, így Ön git diff vagy git egyesítheti őket az aktuális ággal. A git pull futtatni fogja az aktuális ág által követett távoli brach-ot, majd egyesíti az eredményt. A git fetch segítségével megnézheti, hogy vannak-e frissítések a távoli ágon, anélkül, hogy azokat össze kellene egyesíteni a helyi fiókkal.
|
Git Fetch
A helyi fiókváltozásokat letölti a származástól a letöltésig. A Fetch a távoli repótól megkéri az összes olyan elkötelezettséget, amelyet mások elkövettek, de Ön nem rendelkezik a helyi repóval. A Fetch letölti ezeket a parancsokat, és felveszi a helyi adattárba.
Git Merge
Az egyesítés paranccsal alkalmazhatja a letöltés útján letöltött módosításokat. Az egyesítés felveszi a lekérésből visszavett feladatokat, és megpróbálja hozzáadni a helyi fiókhoz. Az egyesítés megőrzi a helyi változások végrehajtási előzményeit, így amikor az ágat lökéssel osztja meg, Git tudja, hogy mások hogyan egyesíthetik a változtatásokat.
Git Pull
A Fetch és az Merge elég gyakran fut együtt, így létrejött egy parancs, amely egyesíti a kettőt, pull. A Pull végrehajt egy lekérést, majd egy egyesítést, hogy a letöltött parancsokat hozzáadja a helyi fiókhoz.
|
Egyszerűbben fogalmazva: ha bármilyen internetkapcsolat nélkül fel akart ugrani egy repülőgépre ... indulás előtt csak megtehette a git fetch eredetét . Az összes változtatást beolvassa a számítógépére, de elkülöníti a helyi fejlesztési / munkaterülettől.
A repülőgépen változtathat a helyi munkaterületen, majd egyesítheti a beolvasottal, és megoldhatja az esetleges egyesítési konfliktusokat, az internethez való csatlakozás nélkül. És hacsak valaki nem hajtott végre új változtatásokat a távoli adattárban, akkor amikor megérkezik a rendeltetési helyre, megkapja a push origin  lehetőséget, és elmegy a kávéért.
Ebből a fantasztikus atlassai bemutatóból:
A git fetch parancs letölti a kötelezettségeket, fájlokat és hivatkozásokat a
távoli adattárat a helyi adattárba.
A lekérés az, amit akkor csinálsz, amikor meg akarod nézni, mi mindenki másé
dolgozott. Ez abban hasonlít az SVN frissítéséhez, hogy láthatja
hogyan haladt a központi történelem, de nem kényszeríti
egyesítse a változásokat a tárában. Git izolátumok
a meglévő helyi tartalomból lekérte a tartalmat, abszolút rendelkezik
nincs hatása a helyi fejlesztési munkájára. A letöltött tartalmat kifejezetten ellenőrizni kell a git checkout paranccsal. Ez teszi
előkészíti a kötelezettségvállalások felülvizsgálatának biztonságos módját, mielőtt integrálja őket
a helyi adattár.
Ha tartalmat tölt le egy távoli adattárból, a feladat végrehajtásához git pull és git fetch parancsok állnak rendelkezésre. Megfontolhatja
git beolvasni a két parancs 'biztonságos' verzióját. Letölti
a távoli tartalmat, de nem frissíti a helyi adattár működési állapotát,
aktuális munkáját érintetlenül hagyva. git pull az agresszívabb
alternatív megoldásként letölti a távoli tartalmat az aktív helyi számára
ág, és azonnal hajtsa végre a git merge-t, hogy létrejöjjön az egyesítés
az új távoli tartalomhoz. Ha függőben lévő változások vannak folyamatban
ez konfliktusokat okoz és elindítja az összeolvadási konfliktusmegoldást
folyam.
Git húzással:
Nem kapsz elszigeteltséget.
Nem kell kifejezetten ellenőrizni. Mert hallgatólagosan összeolvad a git.
Az összevonási lépés hatással lesz a helyi fejlődésre, és konfliktusokat okozhat
Alapvetően NEM biztonságos. Agresszív.
Ellentétben a git letöltéssel, ahol csak a .git / refs / távirányítóit érinti, a git pull hatással lesz mind a .git / refs / távirányítóira, mind a .git / refs / fejeire /
Hmmm ... szóval ha nem frissítem a munkamásolatot git fetch-el, akkor hol változtatok? Hol tárolja a Git fetch az új elkötelezettségeket?
Remek kérdés. Valahol elkülöníti a munkapéldányától. De megint hol? Találjuk ki.
A projektkönyvtárban (azaz ahol elvégzi a git parancsokat):
ls. Ez megmutatja a fájlokat és könyvtárakat. Semmi klassz, tudom.
Most tedd ls -a. Ez megmutatja a pontfájlokat, azaz a kezdőbetűket. Ezután láthatja a .git nevű könyvtárat.
Ne cd .git. Ez nyilvánvalóan megváltoztatja a könyvtárat.
Most jön a szórakoztató rész; tedd. Megjelenik a könyvtárak listája. Ref-ket keresünk. Csináljon cd-hivatkozásokat.
Érdekes látni, mi található az összes könyvtárban, de koncentráljunk kettőre. fejek és távirányítók. Használja a cd-t, hogy ellenőrizze őket is.
Bármely git lekérés frissíti a /.git/refs/remotes könyvtárban található elemeket. Nem frissít semmit a /.git/refs/heads könyvtárban.
Bármely git húzás először elvégzi a git lekérését, frissíti az elemeket a /.git/refs/remotes könyvtárban, majd összeolvad a helyi, majd megváltoztatja a fejét a /.git/refs/heads könyvtárban.
Nagyon jó kapcsolódó válasz megtalálható a Hol helyezi el magát a „git fetch”?
Ezenkívül keresse meg a "Slash jelölést" a Git ág elnevezési konvencióinak posztján. Segít jobban megérteni, hogy a Git hogyan helyezi el a dolgokatkülönböző könyvtárakat.
A tényleges különbség megtekintéséhez
Csak csináld:
git fetch eredetmester
git checkout master
Ha a távoli master frissítve lett, akkor egy ilyen üzenetet kap:
A fiókteleped 2 elkötelezettséggel az „origin / master” mögött van, és gyorsan tovább lehet továbbítani.
(a "git pull" használatával frissítse a helyi fiókot)
Ha nem letöltötte, és csak git checkout masteret hajtott végre, akkor a helyi git nem tudná, hogy 2 elkötelezettség van hozzáadva. És csak annyit mondana:
Már a „master” oldalon van
Fiókod naprakész az 'origin / master' névvel.
De ez elavult és helytelen. Ez azért van, mert a git kizárólag annak alapján ad visszajelzést, amit tud. Feledetlen az új kötelezettségvállalásokról, amelyeket még nem húzott le ...
Van-e valamilyen módja annak, hogy megnézzük a távoli új módosításokat, miközben a fiókban helyben dolgozunk?
Egyes IDE-k (pl. Xcode) nagyon okosak, és egy git-lekérés eredményét használják, és feljegyezhetik azokat a kódsorokat, amelyeket a jelenlegi munkaág távoli ágában megváltoztattak. Ha ezt a sort mind a helyi változtatások, mind a távoli elágazás megváltoztatta, akkor ez a vonal pirossal lesz jelölve. Ez nem összeolvadási konfliktus. Ez egy lehetséges összeolvadási konfliktus. Ez egy headsup, amellyel megoldhatja a jövőbeni egyesítési konfliktust, mielőtt a távoli ágról git húzást végezne.
Szórakoztató tipp:
Ha elhozott egy távoli ágat pl. tette:
git fetch origó funkció / 123
Akkor ez a távirányító könyvtárába kerül. Még mindig nem érhető el a helyi könyvtárban. Azonban leegyszerűsíti a fizetését a DWIM távoli fiókjába (tegye, amire gondolok):
git checkout funkció / 123
már nem kell ezt tennie:
git checkout -b feature / 123 origin / feature / 123
További információ erről itt olvasható
|
Az egyetlen különbség a git pull és a git fetch között az, hogy:
git pull húz egy távoli ágról, és összeolvasztja.
A git fetch csak a távoli ágról tölti le, de nem egyesül
azaz git pull = git fetch + git egyesítés ...
|
A Git lehetővé teszi az időrendi szempontból régebbi elkötelezettségek alkalmazását az újabb elkötelezettségek után.
Emiatt az elkötelezettségek átadása a tárak között két lépésre oszlik:
Az új kötelezettségvállalások másolása a távoli fiókról a távoli ág másolatára a helyi repóban.
(repo a repo művelethez) master @ remote >> remote / origin / master @ local
Új kötelezettségvállalások integrálása a helyi fiókba
(belső repo művelet) távoli / origó / master @ helyi >> master @ helyi
Kétféle módon lehet végrehajtani a 2. lépést.
Fork helyi ág az utolsó közös ős után, és adjon hozzá új végrehajtásokat párhuzamosan a helyi adattárban egyedülállóakkal, amelyek a véglegesítéssel egyesülnek az elkötelezettséggel, bezárva a villát.
Helyezzen be új elkötelezettségeket az utolsó közös ős után, és alkalmazza újra a helyi adattár egyedi tulajdonságait.
A git terminológiában az 1. lépés a git lekérés, a 2. lépés a git egyesítés vagy a git újbázis
git pull a git fetch és a git egyesül
|
A Git két parancs segítségével szerzi be a legújabb verzió ágát a távvezérlőtől a lokálisig:
git fetch: A Git megkapja a legújabb verziót a távoli és a helyi között, de nem egyesül automatikusan.

git fetch eredetmester
git log -p mester..eredet / mester
git merge origin / master
A fenti parancsok azt jelentik, hogy a főág legfrissebb verzióját töltsék le az eredetről a távoli és az eredeti főág között. Ezután összehasonlítja a helyi törzságat és a származási törzságat. Végül egyesítsd.
git pull: A Git a távirányítóról fogja letölteni a legújabb verziót, és beolvad a lokálisba.

git pull eredet mester
A fenti parancs megegyezik a git lekéréssel és a git egyesítésével. A gyakorlatban a git lehívása talán biztonságosabb, mert az egyesítés előtt láthatjuk a változásokat, és eldönthetjük, hogy egyesítjük-e.
|
Mi a különbség a git pull és a git fetch között?
Ennek megértéséhez először meg kell értenie, hogy a helyi git nemcsak a helyi adattárat, hanem a távoli adattár helyi másolatát is fenntartja.
A git fetch naprakészvé teszi a távoli adattár helyi másolatát. Például, ha a távoli adattár GitHub - érdemes lehet a távoli adattárban végrehajtott módosításokat beolvasni a távoli adattár helyi példányába. Ez lehetővé teszi olyan műveletek végrehajtását, mint az összehasonlítás vagy az egyesítés.
A git pull viszont a távoli adattár változásait hozza le, ahol a saját kódját őrzi. Általában a git pull először git-lekérést hajt végre, hogy a távoli adattár helyi másolatát naprakész állapotba hozza, majd egyesíti a változtatásokat a saját kódtárába és esetleg a munkamásolatába.
|
git pull == (git lekérés + git egyesítés)
A git fetch nem változik a helyi fiókokban.
Ha már rendelkezik egy helyi adattárral, amelynek távvezérlője be van állítva a kívánt projekthez, a git fetch segítségével megragadhatja az összes ágat és címkét a meglévő távvezérlőhöz. ... A Fetch nem változtat a helyi fiókokban, ezért az újonnan behozott változtatások beépítéséhez össze kell egyesítenie egy távoli ágat egy párosított helyi fiókkal. a githubból
|
Egyszerű grafikus ábrázolás kezdőknek,
itt,
git húzás
lekéri a kódotaz adattárból, és újrabázolja a helyi ... a git pull-ban lehetőség van új elkötelezettségek létrehozására.
de ,
git letöltés
be fogja tölteni a kódot a tárból, és manuálisan újra kell futtatnunk a git rebase használatával
pl: lekérem a szerver mesterről és újraindítom a helyi mesteremben.
1) git pull (az újraindítás automatikusan megtörténik):
git pull eredet mester
itt az eredet a távoli repo mester az ág
2) git lekérés (manuálisan kell újraindítani):
git fetch eredetmester
lekéri a szerver változásait az eredetükről. és addig lesz a helyi, amíg önállóan nem alapozza meg újra. manuálisan kell megoldanunk az ütközéseket a kódok ellenőrzésével.
git rebase eredet / master
ez újrabázolja a kódot lokálissá. előtte győződjön meg róla, hogy a megfelelő ágban van.
|
Megpróbál világos és egyszerű lenni.
A git pull parancs tulajdonképpen egy parancsikon a git lekéréshez, amelyet a konfigurációtól függően követ a git merge vagy a git rebase parancs. Konfigurálhatja a Git adattárat úgy, hogy a git pull egy lekérés, majd egy újraindítás legyen.
|
Valójában Git fenntartja a saját kódjának és
a távoli adattár.
A git fetch parancs frissíti a helyi másolatot azáltal, hogy adatokat kap a távoli adattárból. Erre azért van szükségünk, mert lehet, hogy valaki más módosított néhányat a kódon, és Ön szeretné naprakészen tartani magát.
A git pull parancs a távoli adattár változásait hozza oda, ahol a saját kódját megőrzi. Normális esetben a git pull ezt úgy hajtja végre, hogy először egy „git fetch” -et hajt végre, hogy a távoli adattár helyi másolatát naprakész állapotba hozza, majd egyesíti a változtatásokat a saját kódtárába és esetleg a munkamásolatába.
|
1
2
Következő
Nagyon aktív kérdés. Nyerjen 10 hírnevet a kérdés megválaszolásához. A jó hírnév követelménye megvédi ezt a kérdést a spamektől és a nem válaszolóktól.
Nem a keresett válasz? Böngésszen a git version-control git-pull git-fetch címkével ellátott többi kérdésben, vagy tegye fel saját kérdését.